package com.zenithmind.chat.config;

import com.zenithmind.chat.pojo.entity.ModelConfig;
import com.zenithmind.chat.service.ModelConfigService;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.client.RestTemplate;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * AI配置类 - 重构版
 * 遵循单一职责原则，只负责配置管理
 * 遵循开闭原则，支持动态配置更新
 */
@Slf4j
@Data
@Configuration
@ConfigurationProperties(prefix = "ai")
public class AiConfigNew {

    @Autowired(required = false)
    private ModelConfigService modelConfigService;

    private OpenAiConfig openAi = new OpenAiConfig();
    private OllamaConfig ollama = new OllamaConfig();
    
    // 缓存所有启用的模型配置
    private final Map<String, ModelConfig> modelConfigCache = new ConcurrentHashMap<>();
    
    // 定时任务执行器
    private ScheduledExecutorService scheduler;
    
    /**
     * OpenAI配置
     */
    @Data
    public static class OpenAiConfig {
        /**
         * OpenAI API 密钥
         */
        private String apiKey;
        
        /**
         * OpenAI API 地址
         */
        private String apiUrl = "https://api.openai.com/v1/chat/completions";
        
        /**
         * 默认模型
         */
        private String defaultModel = "gpt-3.5-turbo";
        
        /**
         * 请求超时时间（毫秒）
         */
        private int timeout = 30000;
    }
    
    /**
     * Ollama配置
     */
    @Data
    public static class OllamaConfig {
        /**
         * Ollama API 地址
         */
        private String apiUrl = "http://localhost:11434";
        
        /**
         * 默认模型
         */
        private String defaultModel = "qwen3:8b";
        
        /**
         * 请求超时时间（毫秒）
         */
        private int timeout = 60000;
    }
    
    /**
     * 初始化配置
     */
    @PostConstruct
    public void init() {
        log.info("初始化AI配置...");
        
        // 初始化线程池
        scheduler = Executors.newScheduledThreadPool(1, r -> {
            Thread thread = new Thread(r, "ai-config-refresh");
            thread.setDaemon(true);
            return thread;
        });
        
        // 首次加载配置
        refreshModelConfigs();
        
        // 设置定时任务，每5分钟刷新一次配置
        scheduler.scheduleAtFixedRate(
            this::refreshModelConfigs, 
            5, 
            5, 
            TimeUnit.MINUTES
        );
        
        log.info("AI配置初始化完成");
    }
    
    /**
     * 销毁资源
     */
    @PreDestroy
    public void destroy() {
        if (scheduler != null && !scheduler.isShutdown()) {
            log.info("关闭AI配置定时任务...");
            scheduler.shutdown();
            try {
                if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                    scheduler.shutdownNow();
                }
            } catch (InterruptedException e) {
                scheduler.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
    
    /**
     * 刷新模型配置缓存
     */
    public void refreshModelConfigs() {
        if (modelConfigService == null) {
            log.warn("ModelConfigService未注入，跳过配置刷新");
            return;
        }
        
        try {
            List<ModelConfig> configs = modelConfigService.getAllEnabledModels();
            
            // 清空旧缓存
            modelConfigCache.clear();
            
            // 重新加载配置
            for (ModelConfig config : configs) {
                String key = generateConfigKey(config.getModelType(), config.getModelName());
                modelConfigCache.put(key, config);
            }
            
            log.debug("已刷新{}个模型配置", configs.size());
            
        } catch (Exception e) {
            log.error("刷新模型配置失败", e);
        }
    }
    
    /**
     * 获取模型配置
     *
     * @param modelType 模型类型
     * @param modelName 模型名称
     * @return 模型配置
     */
    public ModelConfig getModelConfig(Integer modelType, String modelName) {
        String key = generateConfigKey(modelType, modelName);
        return modelConfigCache.get(key);
    }
    
    /**
     * 添加模型配置到缓存
     *
     * @param config 模型配置
     */
    public void addModelConfig(ModelConfig config) {
        String key = generateConfigKey(config.getModelType(), config.getModelName());
        modelConfigCache.put(key, config);
        log.debug("已添加模型配置到缓存: {}", key);
    }
    
    /**
     * 从缓存中移除模型配置
     *
     * @param modelType 模型类型
     * @param modelName 模型名称
     */
    public void removeModelConfig(Integer modelType, String modelName) {
        String key = generateConfigKey(modelType, modelName);
        modelConfigCache.remove(key);
        log.debug("已从缓存中移除模型配置: {}", key);
    }
    
    /**
     * 获取所有缓存的模型配置
     *
     * @return 模型配置映射
     */
    public Map<String, ModelConfig> getAllCachedConfigs() {
        return new ConcurrentHashMap<>(modelConfigCache);
    }
    
    /**
     * 生成配置缓存键
     *
     * @param modelType 模型类型
     * @param modelName 模型名称
     * @return 缓存键
     */
    private String generateConfigKey(Integer modelType, String modelName) {
        return modelType + ":" + modelName;
    }
    
    /**
     * AI服务专用RestTemplate
     * 遵循依赖倒置原则，提供统一的HTTP客户端
     */
    @Bean("aiRestTemplate")
    public RestTemplate aiRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        
        // 设置默认请求头
        restTemplate.getInterceptors().add((request, body, execution) -> {
            request.getHeaders().setContentType(MediaType.APPLICATION_JSON);
            return execution.execute(request, body);
        });
        
        return restTemplate;
    }
    
    /**
     * 验证配置是否有效
     *
     * @return 配置是否有效
     */
    public boolean isConfigValid() {
        // 检查OpenAI配置
        if (openAi.getApiKey() == null || openAi.getApiKey().trim().isEmpty()) {
            log.warn("OpenAI API Key未配置");
        }
        
        // 检查Ollama配置
        if (ollama.getApiUrl() == null || ollama.getApiUrl().trim().isEmpty()) {
            log.warn("Ollama API URL未配置");
        }
        
        return true; // 基本配置检查通过
    }
}
